home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / cut.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-03  |  15.3 KB  |  812 lines
  1. #include "FileXStructs.h"
  2. #include "FileXStrings.h"
  3. #include "allprotos.h"
  4.  
  5. static UBYTE BlockFullName[256];        /* Blockverzeichnis- und -filename */
  6.  
  7. void PrintBlock( void )
  8. {
  9.     UBYTE *blockmem;
  10.     ULONG blocklaenge;
  11.  
  12.     if( blockmem = GetClip( &blocklaenge ))
  13.     {
  14.         MyPrint( blockmem, blocklaenge, AktuDD->DisplayTyp, AktuDI->Wnd );
  15.         FreeMem( blockmem, blocklaenge );
  16.     }
  17.     else
  18.         DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  19. }
  20.  
  21. /*
  22.  * void Copy( struct DisplayData *DD )
  23.  *
  24.  * Kopiert den markierten Bereich ins Clipboard.
  25.  */
  26.  
  27. void Copy( struct DisplayData *DD )
  28. {
  29.     if( DD->Flags & DD_MARK)
  30.     {
  31.         ULONG start, end;
  32.  
  33.         DD->Flags &= ~DD_MARK;
  34.         MarkOff( DD );
  35.  
  36.         if( DD->CPos > DD->MPos)
  37.         {
  38.             start = DD->MPos;
  39.             end = DD->CPos;
  40.         }
  41.         else
  42.         {
  43.             start = DD->CPos;
  44.             end = DD->MPos;
  45.         }
  46.     
  47.         SaveClip( DD->FD->Mem + start, end - start + 1 );
  48.         CursorOn( DD );
  49.     }
  50.     else
  51.         DisplayLocaleText( MSG_INFO_GLOBAL_NOBLOCKMARKED );
  52. }
  53.  
  54. static void CutBlock( ULONG start, ULONG end, struct DisplayData *DD )
  55. {
  56.     struct Speicher s;
  57.  
  58.     if(start>end){long dummy=start;start=end;end=dummy;};
  59.  
  60.     s.len=end-start+1;
  61.  
  62.     if(s.mem = AllocMem(s.len,MEMF_ANY))
  63.     {
  64.         memcpy(s.mem,DD->FD->Mem+start,s.len);
  65.         memmove(DD->FD->Mem+start,DD->FD->Mem+end+1,DD->FD->Len-end);
  66.  
  67.         SaveClip( s.mem, s.len );
  68.  
  69.         DD->FD->Len -= s.len;
  70.  
  71.         CursorMarkOff( DD );
  72.  
  73.         AllDisplay( DD->FD, SCROLLERNEU );
  74.         SetScrollerGadget(DD);
  75.  
  76.             /* Haben wir alles weggeschnitten? */
  77.  
  78.         if( DD->FD->Len == 0 )
  79.             DD->CPos = 0;
  80.         else
  81.         {
  82.             /* Falls Ende auch gleichzeitig Fileende ist, */
  83.             /* Cursor auf Fileende-1 setzen */
  84.     
  85.             if( end != DD->FD->Len + s.len - 1 )
  86.                 DD->CPos = start;
  87.             else
  88.                 DD->CPos = DD->FD->Len -1;
  89.             
  90.             CursorMarkOn( DD );
  91.         }
  92.  
  93.                 /* Eintrag in Undolist */
  94.  
  95.         AddUndoCut(start, s, DD->FD );
  96.  
  97.         UpdateAllStatusZeilen( DD->FD );
  98.     }
  99.     else
  100.     {
  101.         MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, s.len );
  102.     }
  103. }
  104.  
  105. void Cut( struct DisplayData *DD )
  106. {
  107.     if((DD->Flags & DD_MARK)&&(!(DD->FD->Typ == FD_GRAB)))
  108.     {
  109.         DD->Flags &= ~DD_MARK;
  110.         MarkOff( DD );
  111.         CutBlock( DD->CPos, DD->MPos, DD );
  112.         CursorOn( DD );
  113.         SetCursor( DD->CPos, DD );
  114.     }
  115.     else
  116.     {
  117.         if( DD->FD->Typ == FD_GRAB)
  118.             DisplayLocaleText( MSG_INFO_GLOBAL_CUTTINGNOTPOSSIBLEINGRABMODE );
  119.         else if( !( DD->Flags & DD_MARK))
  120.             DisplayLocaleText( MSG_INFO_GLOBAL_NOBLOCKMARKED );
  121.     }
  122. }
  123.  
  124. /*
  125.  * void CutBlockForce(ULONG start, ULONG end)
  126.  *
  127.  * Schneidet den Block von start bis end (einschließlich) raus
  128.  * OHNE ihn irgendwo zu speichern
  129.  */
  130.  
  131. void CutBlockForce( ULONG start, ULONG end, struct DisplayData *DD )
  132. {
  133.     ULONG blocklaenge;
  134.  
  135.     if(start>end){ULONG dummy=start;start=end;end=dummy;};
  136.  
  137.     blocklaenge=end-start+1;
  138.  
  139.     memmove(DD->FD->Mem+start,DD->FD->Mem+end+1,DD->FD->Len-end);
  140.  
  141.     DD->FD->Len-=blocklaenge;
  142.  
  143.     CursorMarkOff( DD );
  144.  
  145.     AllDisplay( DD->FD, SCROLLERNEU );
  146.     SetScrollerGadget( DD );
  147.  
  148.         /* Haben wir alles weggeschnitten? */
  149.  
  150.     if( DD->FD->Len == 0 )
  151.         DD->CPos = 0;
  152.     else
  153.     {
  154.         /* Falls Ende auch gleichzeitig Fileende ist, */
  155.         /* Cursor auf Fileende-1 setzen */
  156.  
  157.         if( end != DD->FD->Len + blocklaenge - 1 )
  158.             DD->CPos = start;
  159.         else
  160.             DD->CPos = DD->FD->Len -1;
  161.         
  162.         CursorMarkOn( DD );
  163.     }
  164.  
  165.     UpdateAllStatusZeilen( DD->FD );
  166. }
  167.  
  168. /*
  169.  * void Paste(long pos )
  170.  *
  171.  * Überschreibt den Bereich ab pos mit dem aktuellen Block im Blockspeicher.
  172.  * Falls dieser nicht rein paßt, wird gefragt, ob dieser gekürzt reingeschrieben
  173.  * werden soll.
  174.  *
  175.  * Neudarstellung des Fensterinhaltes.
  176.  */
  177.  
  178. void Paste( struct DisplayData *DD )
  179. {
  180.     struct Speicher s;
  181.  
  182.     s.mem = GetClip( &s.len );
  183.  
  184.     if( s.len && s.mem )
  185.     {
  186.         struct Speicher ps;
  187.  
  188.         if( s.len > DD->FD->Len - DD->CPos )            /* Paßt Block rein? */
  189.         {
  190.             ps.len = DD->FD->Len - DD->CPos;        /* Nein => Länge kürzen */
  191.  
  192.                 /* Garnichts paßt rein => Nichts machen */
  193.  
  194.             if( ps.len == 0 )
  195.                 return;
  196.  
  197.                 /* Fragen: Trotzdem füllen? */
  198.  
  199.             if( FALSE == MyFullRequest( MSG_INFO_GLOBAL_BLOCKDOESNTFIT, MSG_GADGET_YESNO, s.len-ps.len))
  200.                 return;            /* Nein => Benden */
  201.         }
  202.         else
  203.             ps.len = s.len;
  204.  
  205.         if( ps.mem = AllocMem( ps.len, MEMF_ANY ))
  206.         {
  207.                 /* Alten Bereich sichern */
  208.  
  209.             memcpy(ps.mem,DD->FD->Mem+DD->CPos,ps.len);
  210.  
  211.                 /* Block in Speicher kopieren und Display neudarstellen */
  212.  
  213.             memcpy( DD->FD->Mem + DD->CPos, s.mem, ps.len );
  214.  
  215.                 /* Eintrag in Undoliste */
  216.  
  217.             AddUndoPaste(DD->CPos,ps, s, DD->FD);
  218.  
  219.                 /* Alles neudarstellen */
  220.  
  221.             AllDisplay( DD->FD, SCROLLERNEU );
  222.         }
  223.         else
  224.         {
  225.             MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, ps.len );
  226.         }
  227.     }
  228.     else
  229.         DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  230. }
  231.  
  232. /*
  233.  * void InsertBlock( void )
  234.  *
  235.  * Fügt ab DD->CPos einen Block ein. Eintrag in die Undoliste.
  236.  *
  237.  * Neudarstellung des Fensterinhaltes.
  238.  */
  239.  
  240. void InsertBlock( struct DisplayData *DD )
  241. {
  242.     struct Speicher s;
  243.  
  244.     s.mem = GetClip( &s.len );
  245.  
  246.     if( s.len && s.mem )
  247.     {
  248.             /* Prüfen, ob wir neuen Speicher brauchen */
  249.  
  250.         if( DD->FD->RLen - DD->FD->Len >= s.len )
  251.         {
  252.                 /* Rest nach hinten verschieben */
  253.  
  254.             memmove(DD->FD->Mem+DD->CPos+s.len,DD->FD->Mem+DD->CPos,DD->FD->Len-DD->CPos);
  255.  
  256.                 /* Block einfügen */
  257.  
  258.             memcpy(DD->FD->Mem+DD->CPos,s.mem,s.len);
  259.             
  260.             DD->FD->Len+=s.len;
  261.         }
  262.         else
  263.         {
  264.             UBYTE *neumem;
  265.             long neulaenge=s.len+DD->FD->Len;
  266.  
  267.             if(neumem = AllocMem(neulaenge,MEMF_ANY))
  268.             {
  269.                     /* Den sich nicht ändernden Anfang kopieren */
  270.  
  271.                 memcpy(neumem,DD->FD->Mem,DD->CPos);
  272.                 
  273.                     /* Block kopieren */
  274.  
  275.                 memcpy(neumem+DD->CPos,s.mem,s.len);
  276.  
  277.                     /* Den Rest kopieren */
  278.  
  279.                 memcpy(neumem+DD->CPos+s.len,DD->FD->Mem+DD->CPos,DD->FD->Len-DD->CPos);
  280.  
  281.                     /* Alten Speicher freigeben */
  282.  
  283.                 if( DD->FD->Mem && DD->FD->RLen )
  284.                 {
  285.                     FreeMem( DD->FD->Mem, DD->FD->RLen );
  286.                     DD->FD->Mem = 0;
  287.                     DD->FD->RLen = DD->FD->Len = 0;
  288.                 }
  289.  
  290.                     /* Neuen Speicher eintragen */
  291.  
  292.                 DD->FD->Mem=neumem;
  293.                 DD->FD->RLen = DD->FD->Len = neulaenge;
  294.             }
  295.             else
  296.             {
  297.                 MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, neulaenge );
  298.                 return;
  299.             }
  300.         }
  301.  
  302.         AddUndoInsert( DD->CPos, s, DD->FD);
  303.  
  304.         SetScrollerGadget(DD);
  305.         AllDisplay( DD->FD, SCROLLERNEU );
  306.         UpdateAllStatusZeilen(DD->FD);
  307.  
  308.         if( DD->FD->Len - s.len == 0 ) CursorMarkOn(DD);
  309.     }
  310.     else
  311.         DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  312. }
  313.  
  314.  
  315. /*
  316.  * void InsertBlockForce(long pos, UBYTE *mem, ULONG len, struct DisplayData *DD )
  317.  *
  318.  * Fügt ab pos einen Block ein. Kein Eintrag in die Undoliste.
  319.  *
  320.  * Neudarstellung des Fensterinhaltes.
  321.  */
  322.  
  323. void InsertBlockForce( long pos, UBYTE *mem, ULONG len, struct DisplayData *DD )
  324. {
  325.     if( len && mem )
  326.     {
  327.             /* Prüfen, ob wir neuen Speicher brauchen */
  328.  
  329.         if(DD->FD->RLen-DD->FD->Len >= len )
  330.         {
  331.                 /* Rest nach hinten verschieben */
  332.  
  333.             memmove(DD->FD->Mem+pos+len,DD->FD->Mem+pos,DD->FD->Len-pos);
  334.  
  335.                 /* Block einfügen */
  336.  
  337.             memcpy(DD->FD->Mem+pos,mem,len);
  338.             
  339.             DD->FD->Len+=len;
  340.         }
  341.         else
  342.         {
  343.             UBYTE *neumem;
  344.             long neulaenge=len+DD->FD->Len;
  345.  
  346.             if(neumem = AllocMem(neulaenge,MEMF_ANY))
  347.             {
  348.                     /* Den sich nicht ändernden Anfang kopieren */
  349.  
  350.                 memcpy(neumem,DD->FD->Mem,pos);
  351.                 
  352.                     /* Block kopieren */
  353.  
  354.                 memcpy(neumem+pos,mem,len);
  355.  
  356.                     /* Den Rest kopieren */
  357.  
  358.                 memcpy(neumem+pos+len,DD->FD->Mem+pos,DD->FD->Len-pos);
  359.  
  360.                     /* Alten Speicher freigeben */
  361.  
  362.                 if( DD->FD->Mem && DD->FD->RLen )
  363.                 {
  364.                     FreeMem( DD->FD->Mem, DD->FD->RLen );
  365.                     DD->FD->Mem = 0;
  366.                     DD->FD->RLen = DD->FD->Len = 0;
  367.                 }
  368.  
  369.                     /* Neuen Speicher eintragen */
  370.  
  371.                 DD->FD->Mem=neumem;
  372.                 DD->FD->RLen = DD->FD->Len = neulaenge;
  373.             }
  374.             else
  375.             {
  376.                 MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, neulaenge );
  377.                 return;
  378.             }
  379.         }
  380.  
  381.         SetScrollerGadget(DD);
  382.         AllDisplay( DD->FD, SCROLLERNEU );
  383.         UpdateAllStatusZeilen(DD->FD);
  384.  
  385.         if( DD->FD->Len - len == 0 ) CursorMarkOn(DD);
  386.     }
  387.     else
  388.         DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  389. }
  390.  
  391. /*
  392.  * void AppendBlock( void )
  393.  *
  394.  * Fügt Clipboard am Ende ein.
  395.  *
  396.  * Neudarstellung des Fensterinhaltes.
  397.  */
  398.  
  399. void AppendBlock( struct DisplayData *DD )
  400. {
  401.     struct Speicher s;
  402.  
  403.     s.mem = GetClip( &s.len );
  404.  
  405.     if( s.len && s.mem )
  406.     {
  407.             /* Prüfen, ob wir neuen Speicher brauchen */
  408.  
  409.         if( DD->FD->RLen-DD->FD->Len >= s.len )
  410.         {
  411.                 /* Block einfügen */
  412.  
  413.             memcpy(DD->FD->Mem+DD->FD->Len,s.mem,s.len);
  414.             
  415.             DD->FD->Len+=s.len;
  416.         }
  417.         else
  418.         {
  419.             UBYTE *neumem;
  420.             long neulaenge=s.len+DD->FD->Len;
  421.  
  422.             if(neumem = AllocMem(neulaenge,MEMF_ANY))
  423.             {
  424.                     /* Den sich nicht ändernden Anfang kopieren */
  425.  
  426.                 memcpy(neumem,DD->FD->Mem,DD->FD->Len);
  427.                 
  428.                     /* Block kopieren */
  429.  
  430.                 memcpy(neumem+DD->FD->Len,s.mem,s.len);
  431.  
  432.                     /* Alten Speicher freigeben */
  433.  
  434.                 if( DD->FD->Mem && DD->FD->RLen )
  435.                 {
  436.                     FreeMem( DD->FD->Mem, DD->FD->RLen );
  437.                     DD->FD->Mem = 0;
  438.                     DD->FD->RLen = DD->FD->Len = 0;
  439.                 }
  440.  
  441.                     /* Neuen Speicher eintragen */
  442.  
  443.                 DD->FD->Mem=neumem;
  444.                 DD->FD->RLen=DD->FD->Len=neulaenge;
  445.             }
  446.             else
  447.             {
  448.                 MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, neulaenge );
  449.                 return;
  450.             }
  451.         }
  452.  
  453.         AddUndoInsert(DD->FD->Len-s.len, s, DD->FD);
  454.  
  455.         SetScrollerGadget(DD);
  456.         AllDisplay( DD->FD, SCROLLERNEU );
  457.         UpdateAllStatusZeilen(DD->FD);
  458.  
  459.         if( DD->FD->Len - s.len == 0 ) CursorMarkOn(DD);
  460.     }
  461.     else
  462.          DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  463. }
  464.  
  465. /*
  466.  * BOOL LoadBlock(char *fullname)
  467.  *
  468.  * Läd einen Block ein
  469.  */
  470.  
  471. BOOL LoadBlock(char *fullname)
  472. {
  473.     BPTR fh;
  474.     BOOL Success=FALSE;
  475.  
  476.     if(fh=Open(fullname,MODE_OLDFILE))
  477.     {
  478.         ULONG blocklaenge;
  479.         UBYTE *blockmem;
  480.  
  481.         blocklaenge=GetFileLaenge(fh);
  482.  
  483.         if(blocklaenge)
  484.         if(blockmem = AllocMem(blocklaenge,MEMF_ANY))
  485.         {
  486.             Read(fh,blockmem,blocklaenge);
  487.  
  488.             SaveClip( blockmem, blocklaenge );
  489.  
  490.             FreeMem( blockmem, blocklaenge );
  491.             Success = TRUE;
  492.         }
  493.         else
  494.         {
  495.             MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, blocklaenge );
  496.         }
  497.  
  498.         Close(fh);
  499.     }
  500.     else
  501.         MyRequest( MSG_INFO_GLOBAL_CANTOPENFILE, ( ULONG )fullname );
  502.  
  503.     return(Success);        
  504. }
  505.  
  506. /*
  507.  * BOOL LoadBlockFR(void)
  508.  *
  509.  * Öffnet einen FileRequester und läd einen Block ein
  510.  */
  511.  
  512. BOOL LoadBlockFR(void)
  513. {
  514.     if( MyRequestFile( BlockFullName, GetStr( MSG_WINDOWTITLE_LOADBLOCK ), 0, FALSE ))
  515.         return( LoadBlock( BlockFullName ));
  516.     else
  517.         return( FALSE );
  518. }
  519.  
  520. /*
  521.  * BOOL SaveBlock(char *Name)
  522.  *
  523.  * Speichert einen Block ab.
  524.  */
  525.  
  526. BOOL SaveBlock( char *Name )
  527. {
  528.     BPTR fh;
  529.     BOOL Success=FALSE;
  530.  
  531.     UBYTE *blockmem;
  532.     ULONG blocklaenge;
  533.  
  534.     if( blockmem = GetClip( &blocklaenge ))
  535.     {
  536.             /* Prüfen, ob File existiert. Falls ja, fragen, ob es überschrieben */
  537.             /* werden soll */
  538.  
  539.         if(!(mainflags&MF_OVERWRITE))
  540.             if(GetFileLaengeName(Name))
  541.                 if( 0 == MyFullRequest( MSG_INFO_GLOBAL_FILEALREADYEXISTS, MSG_GADGET_YESNO, ( ULONG )Name ))
  542.                     return(Success);
  543.  
  544.         if(fh=Open(Name,MODE_NEWFILE))
  545.         {
  546.             if(blocklaenge!=Write(fh,blockmem,blocklaenge))
  547.             {
  548.                     /* Falls nicht vollständig geschrieben, löschen */
  549.     
  550.                 Close(fh);
  551.                 MyRequest( MSG_INFO_GLOBAL_CANTSAVEFILE, ( ULONG )Name );
  552.                 DeleteFile(Name);
  553.             }
  554.             else
  555.             {
  556.                 Success = TRUE;
  557.     
  558.                 Close( fh );
  559.             }
  560.         }
  561.         else
  562.             MyRequest( MSG_INFO_GLOBAL_CANTOPENFILE, ( ULONG )Name );
  563.  
  564.         FreeMem( blockmem, blocklaenge );
  565.     }
  566.     else
  567.         DisplayLocaleText( MSG_INFO_GLOBAL_BUFFEREMPTY );
  568.  
  569.     return( Success );
  570. }
  571.  
  572. /*
  573.  * BOOL SaveBlockFR( void )
  574.  *
  575.  * Öffnet einen FileRequester und speichert einen Block ab.
  576.  */
  577.  
  578. BOOL SaveBlockFR( void )
  579. {
  580.     if( MyRequestFile( BlockFullName, GetStr( MSG_WINDOWTITLE_SAVEBLOCK ), 0, FALSE ))
  581.         return( SaveBlock( BlockFullName ));
  582.     else
  583.         return( FALSE );
  584. }
  585.  
  586.  
  587. /*
  588.  * void Fill(ULONG start, ULONG end,UBYTE *was,ULONG laenge)
  589.  * 
  590.  * Füllt den bestimmten Bereich.
  591.  */
  592.  
  593. void Fill( ULONG start, ULONG end, UBYTE *was, ULONG laenge, struct DisplayData *DD )
  594. {
  595.     struct Speicher f1, f2;
  596.  
  597.     if(laenge==0)return;
  598.  
  599.     if(start>end){ULONG dummy=start;start=end;end=dummy;}
  600.  
  601.     f1.len = f2.len = end-start+1;
  602.  
  603.     if(f1.mem = AllocMem(f1.len,MEMF_ANY))
  604.     {
  605.     if(f2.mem = AllocMem(f1.len,MEMF_ANY))
  606.     {
  607.         long pos=start;
  608.  
  609.             /* Alten Bereich sichern */
  610.  
  611.         memcpy(f1.mem,DD->FD->Mem+pos,f1.len);
  612.  
  613.             /* Bereich füllen */
  614.  
  615.         end++;
  616.  
  617.         while(start+laenge<=end)
  618.         {
  619.             memcpy(DD->FD->Mem+start,was,laenge);
  620.             start+=laenge;
  621.         }
  622.  
  623.         if(start<=end)
  624.         {
  625.             memcpy(DD->FD->Mem+start,was,end-start);
  626.         }
  627.  
  628.         AllDisplay( DD->FD, SCROLLERNEU );
  629.  
  630.             /* Neuen Bereich sichern */
  631.  
  632.         memcpy(f2.mem,DD->FD->Mem+pos,f1.len);
  633.  
  634.             /* Eintrag in Undoliste */
  635.  
  636.         AddUndoPaste(pos,f1,f2, DD->FD);
  637.     }
  638.     else
  639.     {
  640.         MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, f1.len );
  641.         FreeMem(f1.mem,f1.len);
  642.     }
  643.     }
  644.     else
  645.         MyRequest( MSG_INFO_GLOBAL_CANTALLOCMEM, f1.len );
  646. }
  647.  
  648. /****************************** FillWindow ******************************/
  649.  
  650. static UBYTE fillstring[256];
  651. static ULONG fillmode = FM_STRING;
  652.  
  653. void SetFillString( char *String )
  654. {
  655.     strcpy( fillstring, String );
  656. }
  657.  
  658. UBYTE *GetFillString( void )
  659. {
  660.     return( fillstring );
  661. }
  662.  
  663. void SetFillMode( ULONG Mode )
  664. {
  665.     fillmode = Mode;
  666. }
  667.  
  668. ULONG GetFillMode( void )
  669. {
  670.     return( fillmode );
  671. }
  672.  
  673. enum {
  674. GD_FILL_STRINGFILL,
  675. GD_FILL_STRING,
  676. GD_FILL_FILL,
  677. GD_FILL_CANCEL
  678. };
  679.  
  680. static struct MyNewGadget FillNewGadgets[] =
  681. {
  682.     CHECKBOX_KIND, 0, 0, 0, MSG_GADGET_FILL_STRINGFILL, 0, 0, 0, 0, 0,
  683.     STRING_KIND, 0, 0, 0, MSG_GADGET_FILL_STRING, 0, 256, 0, 0, 30,
  684.  
  685.     BUTTON_KIND, GP_LEFTBOTTOM, 0, 0, MSG_GADGET_FILL_FILL, 0, 0, 0, 0, 0,
  686.     BUTTON_KIND, GP_RIGHTBOTTOM, 0, 0, MSG_GADGET_CANCEL, 0, 0, 0, 0, 0,
  687.     0
  688. };
  689.  
  690. static struct WindowData FillWD =
  691. {
  692.     NULL,    NULL,    FALSE, NULL, NULL,
  693.     0,0,
  694.     &FillNewGadgets[ 0 ], 4
  695. };
  696.  
  697. static void DoFillWndMsg( void )
  698. {
  699.     struct IntuiMessage    *m, Msg;
  700.     struct Gadget *gad;
  701.  
  702.     int Select = -1;            /* Wie wurde Window verlassen ? (Nicht/Cancel/Fill) */
  703.  
  704.     while( m = GT_GetIMsg( FillWD.Wnd->UserPort ))
  705.     {
  706.         CopyMem(( char * )m, ( char * )&Msg, (long)sizeof( struct IntuiMessage ));
  707.  
  708.         GT_ReplyIMsg( m );
  709.  
  710.         KeySelect(FillWD.Gadgets, &Msg);
  711.  
  712.         gad = (struct Gadget *) Msg.IAddress;
  713.  
  714.         switch( Msg.Class )
  715.         {
  716.             case    IDCMP_REFRESHWINDOW:
  717.                 GT_BeginRefresh( FillWD.Wnd );
  718.                 GT_EndRefresh( FillWD.Wnd, TRUE );
  719.                 break;
  720.  
  721.             case    IDCMP_VANILLAKEY:
  722.                 if( Msg.Code == 13)
  723.                     Select = 1;
  724.                 break;
  725.  
  726.             case    IDCMP_CLOSEWINDOW:
  727.                 Select = 0;
  728.                 break;
  729.  
  730.             case    IDCMP_GADGETUP:
  731.                 switch(gad->GadgetID)
  732.                 {
  733.                     case GD_FILL_STRING:
  734.                         if( FillNewGadgets[ GD_FILL_STRINGFILL ].CurrentValue == FALSE )
  735.                             if(-1==TestHexString(GetString(FillWD.Gadgets[GD_FILL_STRING])))
  736.                                 ActivateGadget(FillWD.Gadgets[GD_FILL_STRING],FillWD.Wnd,0);
  737.                         break;
  738.  
  739.                     case GD_FILL_STRINGFILL:
  740.                         ((struct MyNewGadget *)gad->UserData)->CurrentValue = !((struct MyNewGadget *)gad->UserData)->CurrentValue;
  741.                         break;    
  742.  
  743.                     case GD_FILL_FILL:
  744.                         Select = 1;
  745.                         break;
  746.  
  747.                     case GD_FILL_CANCEL:
  748.                         Select = 0;
  749.                         break;
  750.                 }
  751.                 break;
  752.         }
  753.     }
  754.  
  755.     if( Select == 1 )        /* Falls nicht cancel, Werte merken */
  756.     {
  757.         strcpy( fillstring, GetString( FillWD.Gadgets[ GD_FILL_STRING ] ));
  758.  
  759.         if( FillNewGadgets[ GD_FILL_STRINGFILL ].CurrentValue )
  760.             fillmode = FM_STRING;
  761.         else
  762.             fillmode = FM_NUMBER;
  763.     }
  764.  
  765.     if( Select != -1 )
  766.     {
  767.         MyRemoveSignal( 1L << FillWD.Wnd->UserPort->mp_SigBit );
  768.         NewCloseAWindow( &FillWD );
  769.     }
  770.  
  771.     if( Select == 1 )
  772.         FillDD( AktuDD );
  773. }
  774.  
  775. void OpenFillWindow( void )
  776. {
  777.     ULONG err;
  778.  
  779.     if( FillWD.Wnd )
  780.     {
  781.         ActivateWindow( FillWD.Wnd );
  782.         return;
  783.     }
  784.  
  785.     FillNewGadgets[ GD_FILL_STRING ].CurrentValue = (LONG) fillstring;
  786.     FillNewGadgets[ GD_FILL_STRINGFILL ].CurrentValue =    ( fillmode & FM_STRING ) ? TRUE : FALSE;
  787.  
  788.     if( err = NewOpenAWindow( &FillWD, GetStr(MSG_WINDOWTITLE_FILL)))
  789.         MyRequest( MSG_INFO_GLOBAL_CANTOPENWINDOW, err );
  790.     else
  791.     {
  792.         MyAddSignal( 1L << FillWD.Wnd->UserPort->mp_SigBit, &DoFillWndMsg );
  793.     }
  794. }
  795.  
  796. void FillDD( struct DisplayData *DD )
  797. {
  798.     switch(GetFillMode())
  799.     {
  800.         case FM_STRING:
  801.             Fill(DD->CPos,DD->MPos,GetFillString(),strlen( GetFillString()), DD);
  802.             break;
  803.         case FM_NUMBER:
  804.             if(-1!=TestHexString(GetFillString()))
  805.             {
  806.                 UBYTE hexfillstring[256];
  807.                 
  808.                 Fill(DD->CPos,DD->MPos,hexfillstring,ConvertHexstringToHexnumber(GetFillString(),hexfillstring), DD);
  809.             }
  810.             break;
  811.     }
  812. }